Transactional Virtual Memory with Fine-grained Range Lock Support

Lightweighted Recoverable Virtual Memory (RVM) [5] is a software mechanism to support persistent virtual memory regions in the face of system crashes. Regions maintained by RVM are accessed in transactions. RVM can undo all the memory changes in aborted transactions, while committed transactions have their changes written to secondary storages. Therefore transactional atomicity and durability are guaranteed. RVM is implemented as a programming library that can be linked to application programs. Using RVM, applications which must maintain persistent data structures and survive system crashes can be easily implemented with less efforts. However, RVM requires that programmers use thread locks themselves to synchronize among concurrent transactions. That is, RVM does not support serialization, which is the ’I’ or Isolation property in ACID [3]. To reduce programers’ burdens of implementing their own serialization mechanisms, we add serialization support to RVM, thus providing the full ACID semantics of transactions to virtual memory. Our transactional virtual memory (TVM) aims at ease of use by programmers, efficiency, and portability. It allows high concurrency among transactions with low overhead. We use strict two phase locking protocol for serialization. As RVM, TVM is also implemented as a programming library. TVM keeps RVM’s interface and adds three new library calls so that existing RVM applications can be linked to TVM without any change. The three new calls are to request a read, write, or intension range lock on a memory range in RVM maintained regions. A lot of popular synchronization programming styles are easily realized by these range lock calls. We support fine-grained byte range locks. All the range lock information of transactions is recorded by TVM. A thread is blocked when it requests a range lock conflicting with other transactions and is woken up after those transactions end. Two range lock algorithms are put forward. The basic algorithm is easy to implement and efficient when small number of locks are used concurrently. The advanced algorithm uses two tree structures to help locate the conflicting range locks directly and therefore offers better performance when the number of locks is large. Both approaches ensure forward progress by avoiding live locks and by providing a deadlock detection mechanism. Furthermore, range locks are implemented using common synchronization primitives supported by most thread packages. This is preferred to an implemetation within a specific thread package for portability reasons. The remaining of the paper is organized as follows. We begin with a clear description of the existing RVM mechanism. Then we discuss our major design decisions aiming at ease of use, efficiency, and portability. Section 3 elaborates detailed design and implementation of the two range lock algorithms. Then section 4 decribes our deadlock detection mechanism. An evaluation of TVM is presented in Section 5. In Section 6, we describe the course material covered in our project. And finally, section 7 concludes our discussion.